AsyncIO Hodisalar Tsikli: Korutinlarni Rejalashtirish va Vazifalarni Boshqarish

Asinxron dasturlash zamonaviy dasturiy ta'minotni ishlab chiqishda tobora muhim ahamiyat kasb etib, ilovalarga asosiy oqimni bloklamasdan bir vaqtning o'zida bir nechta vazifalarni bajarishga imkon beradi. Pythonning asyncio kutubxonasi hodisalar tsikli kontseptsiyasi asosida qurilgan asinxron kod yozish uchun kuchli freymvorkni taqdim etadi. Hodisalar tsikli korutinlarni qanday rejalashtirishi va vazifalarni qanday boshqarishini tushunish samarali va kengaytiriladigan asinxron ilovalarni yaratish uchun juda muhimdir.

AsyncIO Hodisalar Tsiklini Tushunish

asyncioning markazida hodisalar tsikli yotadi. Bu asinxron vazifalarni boshqaradigan va bajaradigan bir oqimli, bir protsessli mexanizmdir. Uni kodingizning turli qismlari ijrosini muvofiqlashtiradigan markaziy dispetcher deb o'ylang. Hodisalar tsikli ro'yxatdan o'tgan asinxron operatsiyalarni doimiy ravishda kuzatib boradi va ular tayyor bo'lganda bajaradi.

Hodisalar Tsiklining Asosiy Vazifalari:

• Korutinlarni Rejalashtirish: Korutinlarni qachon va qanday bajarishni aniqlash.
• Kiritish/Chiqarish Amallarini Bajarish: Soketlar, fayllar va boshqa kiritish/chiqarish resurslarining tayyorligini kuzatish.
• Qayta Qo'ng'iroqlarni (Callbacks) Bajarish: Ma'lum vaqtlarda yoki ma'lum hodisalardan keyin bajarilishi uchun ro'yxatdan o'tgan funksiyalarni chaqirish.
• Vazifalarni Boshqarish: Asinxron vazifalarni yaratish, boshqarish va ularning bajarilish jarayonini kuzatish.

Korutinlar: Asinxron Kodning Qurilish Bloklari

Korutinlar - bu ijro paytida ma'lum nuqtalarda to'xtatilishi va qayta tiklanishi mumkin bo'lgan maxsus funksiyalardir. Pythonda korutinlar async va await kalit so'zlari yordamida aniqlanadi. Korutin await iborasiga duch kelganda, u boshqaruvni hodisalar tsikliga qaytaradi va boshqa korutinlarning ishlashiga imkon beradi. Ushbu kooperativ ko'p vazifalilik yondashuvi oqimlar yoki protsesslarning qo'shimcha xarajatlarisiz samarali bir vaqtda ishlashni ta'minlaydi.

Korutinlarni Aniqlash va Ulardan Foydalanish:

Korutin async kalit so'zi yordamida aniqlanadi:

async def my_coroutine():
  print("Korutin boshlandi")
  await asyncio.sleep(1)  # Kiritish/chiqarishga bog'liq operatsiyani simulyatsiya qilish
  print("Korutin tugadi")

Korutinni bajarish uchun uni asyncio.run(), loop.run_until_complete() yordamida yoki vazifa yaratish orqali hodisalar tsikliga rejalashtirishingiz kerak (vazifalar haqida keyinroq batafsil):

async def main():
  await my_coroutine()

asyncio.run(main())

Korutinlarni Rejalashtirish: Hodisalar Tsikli Nimani Bajarishni Qanday Tanlaydi

Hodisalar tsikli qaysi korutinni keyingi bajarishni hal qilish uchun rejalashtirish algoritmidan foydalanadi. Ushbu algoritm odatda adolat va ustuvorlikka asoslanadi. Korutin boshqaruvni topshirganda, hodisalar tsikli o'z navbatidan keyingi tayyor korutinni tanlaydi va uning ijrosini davom ettiradi.

Kooperativ Ko'p Vazifalilik:

asyncio kooperativ ko'p vazifalilikka tayanadi, ya'ni korutinlar await kalit so'zi yordamida boshqaruvni hodisalar tsikliga aniq topshirishlari kerak. Agar korutin uzoq vaqt davomida boshqaruvni topshirmasa, u hodisalar tsiklini bloklashi va boshqa korutinlarning ishlashiga to'sqinlik qilishi mumkin. Shuning uchun korutinlaringizning to'g'ri ishlashini va, ayniqsa, kiritish/chiqarish bilan bog'liq operatsiyalarni bajarishda, tez-tez boshqaruvni topshirishini ta'minlash juda muhimdir.

Rejalashtirish Strategiyalari:

Hodisalar tsikli odatda Birinchi Kelgan, Birinchi Ketadi (FIFO) rejalashtirish strategiyasidan foydalanadi. Biroq, u korutinlarni ularning shoshilinchligi yoki muhimligiga qarab ustuvorlashtirishi ham mumkin. Ba'zi asyncio ilovalari sizning maxsus ehtiyojlaringizga mos ravishda rejalashtirish algoritmini sozlashga imkon beradi.

Vazifalarni Boshqarish: Bir Vaqtda Ishlash Uchun Korutinlarni O'rash

Korutinlar asinxron operatsiyalarni belgilasa-da, vazifalar ushbu operatsiyalarning hodisalar tsikli ichidagi haqiqiy ijrosini ifodalaydi. Vazifa - bu bekor qilish, istisnolarni qayta ishlash va natijani olish kabi qo'shimcha funksiyalarni ta'minlaydigan korutin atrofidagi o'ramdir. Vazifalar hodisalar tsikli tomonidan boshqariladi va bajarish uchun rejalashtiriladi.

Vazifalarni Yaratish:

Siz korutindan asyncio.create_task() yordamida vazifa yaratishingiz mumkin:

async def my_coroutine():
  await asyncio.sleep(1)
  return "Natija"

async def main():
  task = asyncio.create_task(my_coroutine())
  result = await task  # Vazifaning tugashini kutish
  print(f"Vazifa natijasi: {result}")

asyncio.run(main())

Vazifa Holatlari:

Vazifa quyidagi holatlardan birida bo'lishi mumkin:

• Kutish rejimida (Pending): Vazifa yaratilgan, lekin hali bajarilishi boshlanmagan.
• Bajarilmoqda (Running): Vazifa hozirda hodisalar tsikli tomonidan bajarilmoqda.
• Bajarildi (Done): Vazifa muvaffaqiyatli yakunlandi.
• Bekor qilindi (Cancelled): Vazifa tugashidan oldin bekor qilindi.
• Istisno (Exception): Vazifa bajarilish paytida istisnoga duch keldi.

Vazifani Bekor Qilish:

Siz task.cancel() usuli yordamida vazifani bekor qilishingiz mumkin. Bu korutin ichida CancelledError xatosini yuzaga keltiradi, bu esa unga chiqishdan oldin har qanday resurslarni tozalash imkonini beradi. Kutilmagan xatti-harakatlarning oldini olish uchun korutinlaringizda CancelledErrorni to'g'ri qayta ishlash muhimdir.

async def my_coroutine():
  try:
    await asyncio.sleep(5)
    return "Natija"
  except asyncio.CancelledError:
    print("Korutin bekor qilindi")
    return None

async def main():
  task = asyncio.create_task(my_coroutine())
  await asyncio.sleep(1)
  task.cancel()
  try:
    result = await task
    print(f"Vazifa natijasi: {result}")
  except asyncio.CancelledError:
    print("Vazifa bekor qilindi")

asyncio.run(main())

Korutinlarni Rejalashtirish va Vazifalarni Boshqarish: Batafsil Taqqoslash

Garchi korutinlarni rejalashtirish va vazifalarni boshqarish asyncioda chambarchas bog'liq bo'lsa-da, ular turli maqsadlarga xizmat qiladi. Korutinlarni rejalashtirish - bu hodisalar tsiklining qaysi korutinni keyingi bajarishni hal qilish mexanizmi bo'lsa, vazifalarni boshqarish - bu korutinlarning vazifalar sifatida bajarilishini yaratish, boshqarish va kuzatish jarayonidir.

Korutinlarni Rejalashtirish:

• Fokus: Korutinlarning bajarilish tartibini aniqlash.
• Mexanizm: Hodisalar tsiklining rejalashtirish algoritmi.
• Boshqaruv: Rejalashtirish jarayoni ustidan cheklangan nazorat.
• Abstraksiya darajasi: Past darajali, to'g'ridan-to'g'ri hodisalar tsikli bilan o'zaro ta'sir qiladi.

Vazifalarni Boshqarish:

• Fokus: Korutinlarning vazifalar sifatidagi hayot tsiklini boshqarish.
• Mexanizm: asyncio.create_task(), task.cancel(), task.result().
• Boshqaruv: Korutinlarning bajarilishi ustidan ko'proq nazorat, jumladan, bekor qilish va natijani olish.
• Abstraksiya darajasi: Yuqori darajali, bir vaqtda bajariladigan operatsiyalarni boshqarishning qulay usulini taqdim etadi.

Qachon Korutinlardan To'g'ridan-to'g'ri Foydalanish va Qachon Vazifalardan foydalanish kerak:

Ko'p hollarda siz vazifalar yaratmasdan to'g'ridan-to'g'ri korutinlardan foydalanishingiz mumkin. Biroq, quyidagi hollarda vazifalar zarur:

• Bir nechta korutinni bir vaqtda ishga tushirish kerak bo'lganda.
• Ishlayotgan korutinni bekor qilish kerak bo'lganda.
• Korutin natijasini olish kerak bo'lganda.
• Korutin tomonidan yuzaga kelgan istisnolarni qayta ishlash kerak bo'lganda.

AsyncIOning Amaliy Misollari

Keling, asynciodan asinxron ilovalarni yaratishda qanday foydalanish mumkinligini ko'rsatadigan ba'zi amaliy misollarni ko'rib chiqaylik.

1-misol: Bir Vaqtda Veb-So'rovlar

Ushbu misol asyncio va aiohttp kutubxonasidan foydalanib, bir vaqtning o'zida bir nechta veb-so'rovlarni qanday amalga oshirishni ko'rsatadi:

import asyncio
import aiohttp

async def fetch_url(url):
  async with aiohttp.ClientSession() as session:
    async with session.get(url) as response:
      return await response.text()

async def main():
  urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
  ]

  tasks = [asyncio.create_task(fetch_url(url)) for url in urls]
  results = await asyncio.gather(*tasks)

  for i, result in enumerate(results):
    print(f"{urls[i]} dan natija: {result[:100]}...")  # Birinchi 100 ta belgini chop etish

asyncio.run(main())

Ushbu kod har biri turli URL manzilining mazmunini olish uchun mas'ul bo'lgan vazifalar ro'yxatini yaratadi. asyncio.gather() funksiyasi barcha vazifalar tugashini kutadi va ularning natijalari ro'yxatini qaytaradi. Bu sizga bir nechta veb-sahifalarni bir vaqtning o'zida olish imkonini beradi, bu esa so'rovlarni ketma-ket bajarishga nisbatan ishlash samaradorligini sezilarli darajada oshiradi.

2-misol: Asinxron Ma'lumotlarni Qayta Ishlash

Ushbu misol asyncio yordamida katta hajmdagi ma'lumotlar to'plamini asinxron ravishda qanday qayta ishlashni ko'rsatadi:

import asyncio
import random

async def process_data(data):
  await asyncio.sleep(random.random())  # Qayta ishlash vaqtini simulyatsiya qilish
  return data * 2

async def main():
  data = list(range(100))
  tasks = [asyncio.create_task(process_data(item)) for item in data]
  results = await asyncio.gather(*tasks)

  print(f"Qayta ishlangan ma'lumotlar: {results}")

asyncio.run(main())

Ushbu kod har biri ma'lumotlar to'plamidagi turli elementni qayta ishlash uchun mas'ul bo'lgan vazifalar ro'yxatini yaratadi. asyncio.gather() funksiyasi barcha vazifalar tugashini kutadi va ularning natijalari ro'yxatini qaytaradi. Bu sizga katta hajmdagi ma'lumotlar to'plamini bir vaqtning o'zida qayta ishlash, bir nechta protsessor yadrolaridan foydalanish va umumiy qayta ishlash vaqtini qisqartirish imkonini beradi.

AsyncIO Dasturlash Uchun Eng Yaxshi Amaliyotlar

Samarali va qo'llab-quvvatlanadigan asyncio kodini yozish uchun quyidagi eng yaxshi amaliyotlarga rioya qiling:

• awaitni faqat kutilishi mumkin bo'lgan (awaitable) obyektlarda ishlating: await kalit so'zini faqat korutinlar yoki boshqa kutilishi mumkin bo'lgan obyektlarda ishlatayotganingizga ishonch hosil qiling.
• Korutinlarda bloklovchi operatsiyalardan saqlaning: Sinxron kiritish/chiqarish yoki protsessorga bog'liq vazifalar kabi bloklovchi operatsiyalar hodisalar tsiklini bloklashi va boshqa korutinlarning ishlashiga to'sqinlik qilishi mumkin. Asinxron alternativalardan foydalaning yoki bloklovchi operatsiyalarni alohida oqim yoki protsessga o'tkazing.
• Istisnolarni to'g'ri qayta ishlang: Korutinlar va vazifalar tomonidan yuzaga kelgan istisnolarni qayta ishlash uchun try...except bloklaridan foydalaning. Bu sizning ilovangizni qayta ishlanmagan istisnolar tufayli ishdan chiqishdan saqlaydi.
• Endi kerak bo'lmagan vazifalarni bekor qiling: Endi kerak bo'lmagan vazifalarni bekor qilish resurslarni bo'shatishi va keraksiz hisob-kitoblarning oldini olishi mumkin.
• Asinxron kutubxonalardan foydalaning: Kiritish/chiqarish operatsiyalari uchun veb-so'rovlar uchun aiohttp va ma'lumotlar bazasiga kirish uchun asyncpg kabi asinxron kutubxonalardan foydalaning.
• Kodingizni profillang: asyncio kodingizdagi ishlash samaradorligidagi zaif nuqtalarni aniqlash uchun profillash vositalaridan foydalaning. Bu sizga kodingizni maksimal samaradorlik uchun optimallashtirishga yordam beradi.

AsyncIOning Ilg'or Kontseptsiyalari

Korutinlarni rejalashtirish va vazifalarni boshqarish asoslaridan tashqari, asyncio murakkab asinxron ilovalarni yaratish uchun bir qator ilg'or xususiyatlarni taklif etadi.

Asinxron Navbatlar:

asyncio.Queue korutinlar o'rtasida ma'lumotlar uzatish uchun oqimlar uchun xavfsiz, asinxron navbatni taqdim etadi. Bu ishlab chiqaruvchi-iste'molchi modellarini amalga oshirish yoki bir nechta vazifalarning bajarilishini muvofiqlashtirish uchun foydali bo'lishi mumkin.

Asinxron Sinxronizatsiya Primitivlari:

asyncio qulflar, semaforlar va hodisalar kabi keng tarqalgan sinxronizatsiya primitivlarining asinxron versiyalarini taqdim etadi. Ushbu primitivlardan asinxron kodda umumiy resurslarga kirishni muvofiqlashtirish uchun foydalanish mumkin.

Maxsus Hodisalar Tsikllari:

Garchi asyncio standart hodisalar tsiklini taqdim etsa-da, siz o'zingizning maxsus ehtiyojlaringizga mos keladigan maxsus hodisalar tsikllarini ham yaratishingiz mumkin. Bu asyncioni boshqa hodisalarga asoslangan freymvorklar bilan integratsiya qilish yoki maxsus rejalashtirish algoritmlarini amalga oshirish uchun foydali bo'lishi mumkin.

Turli Mamlakatlar va Sohalarda AsyncIO

asyncioning afzalliklari universal bo'lib, uni turli mamlakatlar va sohalarda qo'llash imkonini beradi. Quyidagi misollarni ko'rib chiqing:

• Elektron tijorat (Global): Eng yuqori savdo mavsumlarida ko'plab bir vaqtda foydalanuvchi so'rovlarini qayta ishlash.
• Moliya (Nyu-York, London, Tokio): Yuqori chastotali savdo ma'lumotlarini qayta ishlash va real vaqt rejimida bozor yangilanishlarini boshqarish.
• O'yin sanoati (Seul, Los-Anjeles): Minglab bir vaqtda o'yinchilarni qabul qila oladigan kengaytiriladigan o'yin serverlarini yaratish.
• Narsalar Interneti (IoT) (Shenchjen, Silikon vodiysi): Minglab ulangan qurilmalardan keladigan ma'lumotlar oqimlarini boshqarish.
• Ilmiy hisoblashlar (Jeneva, Boston): Simulyatsiyalarni ishga tushirish va katta hajmdagi ma'lumotlar to'plamlarini bir vaqtda qayta ishlash.

Xulosa

asyncio Pythonda asinxron ilovalarni yaratish uchun kuchli va moslashuvchan freymvorkni taqdim etadi. Korutinlarni rejalashtirish va vazifalarni boshqarish kontseptsiyalarini tushunish samarali va kengaytiriladigan asinxron kod yozish uchun zarurdir. Ushbu blog postida bayon etilgan eng yaxshi amaliyotlarga rioya qilish orqali siz bir vaqtning o'zida bir nechta vazifalarni bajara oladigan yuqori samarali ilovalarni yaratish uchun asyncio kuchidan foydalanishingiz mumkin.

asyncio bilan asinxron dasturlashni chuqurroq o'rganar ekansiz, mustahkam va kengaytiriladigan ilovalarni yaratishda puxta rejalashtirish va hodisalar tsiklining nozikliklarini tushunish muhim ekanligini unutmang. Bir vaqtda ishlash kuchini qabul qiling va Python kodingizning to'liq salohiyatini oching!